/********************************************************************************
  * @file    SD93F115B_adc.c
  * @author   TEST TEAM 												    	
  * @version  v0															    	
  * @date     Septemper 2022												    	
  * @brief
  *
  * Copyright (C) 2022  Hangzhou SDIC Microelectronics Co., Ltd
*********************************************************************************/

/* Includes */
    
#include "SD93F115B_sdadc.h"
#include "SD93F115B_rcc.h"

/*-----------------------------
 * 函数功能：SDADC相关寄存器恢复到上电默认值
 * 入口参数：None
 * 出口参数：None
 * 返回值  ：None
 * 编写日期：
 * 作者    ：
 *------------------------------*/
void SDADC_DeInit(void)
{
	RCC_APBPeriphResetCmd(RCC_APBPeriph_SDADC, ENABLE);
    RCC_APBPeriphResetCmd(RCC_APBPeriph_SDADC, DISABLE);
}

/*------------------------------------------------------
 * 函数功能：配置IA的相关参数
 * 入口参数：SDADC_IAInitStruct: pointer to a SDADC_IAInitStruct structure that
 *           contains the configuration information for the specified IA peripheral.
 * 出口参数：None
 * 返回值  ：None
 * 编写日期：
 * 作者    ：
 *------------------------------------------------------*/
void SDADC_IAInit(IA_InitTypeDef* SDADC_IAInitStruct)
{
	uint32_t tmpreg=0,tmpreg1=0,tmpreg2=0;
	/* Check the parameters */
	assert_param(IS_SDADC_IA_ExteralChopper(SDADC_IAInitStruct->IA_ExteralChopper));
	assert_param(IS_SDADC_IA_InteralChopper(SDADC_IAInitStruct->IA_InteralChopper));
	assert_param(IS_FUNCTIONAL_STATE(SDADC_IAInitStruct->IA_OSEN));
	assert_param(IS_SDADC_VOS(SDADC_IAInitStruct->IA_VOS));
	assert_param(IS_SDADC_OSSIGN(SDADC_IAInitStruct->IA_OSSIGN));
	assert_param(IS_SDADC_IAD(SDADC_IAInitStruct->IA_IAD));
	assert_param(IS_SDADC_IARCF(SDADC_IAInitStruct->IA_RCF));
	assert_param(IS_SDADC_IAGAIN(SDADC_IAInitStruct->IA_GAIN));
	assert_param(IS_FUNCTIONAL_STATE(SDADC_IAInitStruct->IA_SIEN));
	assert_param(IS_SDADC_SIA(SDADC_IAInitStruct->IA_SIA));
	assert_param(IS_SDADC_IAINNS_Channel(SDADC_IAINNS));
	assert_param(IS_SDADC_IAINPS_Channel(SDADC_IAINPS));
	
	tmpreg=SDADC->IA_CR&0xC0008200;
	
	tmpreg1=SDADC_IAInitStruct->IA_ExteralChopper;
    tmpreg|=(tmpreg1<<27);
	
	tmpreg1=SDADC_IAInitStruct->IA_InteralChopper;
    tmpreg|=(tmpreg1<<24);

    tmpreg1=SDADC_IAInitStruct->IA_VOS;
    tmpreg|=(tmpreg1<<20); 
	
	if(SDADC_IAInitStruct->IA_OSEN==ENABLE)
	tmpreg|=IA_CR_OSEN;
	
	if(SDADC_IAInitStruct->IA_OSSIGN==VOS_Positive_Phase)
	tmpreg|=IA_CR_OSSIGN;
		
	tmpreg1=SDADC_IAInitStruct->IA_IAD;
    tmpreg|=(tmpreg1<<16);

	tmpreg1=SDADC_IAInitStruct->IA_RCF;
    tmpreg|=(tmpreg1<<13);

	tmpreg1=SDADC_IAInitStruct->IA_GAIN;
    tmpreg|=(tmpreg1<<10);
 
 	if(SDADC_IAInitStruct->IA_SIEN==ENABLE)
	tmpreg|=IA_CR_SI;
		
	SDADC->IA_CR=tmpreg;
	
	tmpreg2=SDADC->IA_CR2 & 0xFFFFFFFE;
	
	if(SDADC_IAInitStruct->IA_SIA==IA_SIA_LOW)
	tmpreg2|=IA_CR2_SIA;
	
	SDADC->IA_CR2=tmpreg2;	
		
	
	SDADC_ChannelConfig(SDADC_IAInitStruct->SDADC_IAINPS,SDADC_IAInitStruct->SDADC_IAINNS);

}

/*-----------------------------
 * 函数功能：使能PGIA
 * 入口参数：NewState: ENABLE或者DISABLE
 * 出口参数：None
 * 返回值  ：None
 * 编写日期：
 * 作者    ：
 *------------------------------*/
void SDADC_PGIACmd(FunctionalState NewState)
{
	/* Check the parameters */	 
	assert_param(IS_FUNCTIONAL_STATE(NewState));	
	
	if (NewState == ENABLE)
	{	
		SDADC->IA_CR|=IA_CR_PGIAEN;							
	} 
	else 
	{
		SDADC->IA_CR &=~IA_CR_PGIAEN;		
	}
}

/*------------------------------------
 * 函数功能：配置SDADC信号输入通道 
 * 入口参数：SDADC_IAINPS,SDADC_IAINNS
 * 出口参数：None
 * 返回值  ：None
 * 编写日期：
 * 作者    ：
 *------------------------------------*/
void SDADC_ChannelConfig(uint8_t SDADC_IAINPS,uint8_t SDADC_IAINNS)       
{   
   uint32_t tmpreg=0,tmpreg1=0;
    /* Check the parameters */	
	assert_param(IS_SDADC_IAINNS_Channel(SDADC_IAINNS));
	assert_param(IS_SDADC_IAINPS_Channel(SDADC_IAINPS));
	
	
	tmpreg=SDADC->IA_CR&0xfffd7f00;
	tmpreg1=SDADC_IAINNS; 
    tmpreg|=(tmpreg1<<4); 

	tmpreg1=SDADC_IAINPS;
    tmpreg|=tmpreg1; 
	
	SDADC->IA_CR=tmpreg;
	
}

/*-----------------------------
 * 函数功能：使能PGIA抗EMI干扰功能（默认使能）
 * 入口参数：NewState: ENABLE或者DISABLE
 * 出口参数：None
 * 返回值  ：None
 * 编写日期：
 * 作者    ：
 *------------------------------*/
void SDADC_EMISCmd(FunctionalState NewState)
{
	/* Check the parameters */	 
	assert_param(IS_FUNCTIONAL_STATE(NewState));	
	
	if (NewState != DISABLE)
	{	
		SDADC->IA_CR|=IA_CR_EMIS_EN;							
	} 
	else 
	{
		SDADC->IA_CR &=~IA_CR_EMIS_EN;		
	}
}
/*-----------------------------
 * 函数功能：ADC初始化
 * 入口参数：SDADC_InitStruct: pointer to a SDADC_InitStruct structure that
 *           contains the configuration information for the specified SDADC peripheral.
 * 出口参数：None
 * 返回值  ：None
 * 编写日期：
 * 作者    ：
 *------------------------------*/
void SDADC_Init(SDADC_InitTypeDef* SDADC_InitStruct)
{
	uint32_t tmpreg=0,tmpreg1 = 0;
	/* Check the parameters */
	assert_param(IS_SDADC_BUFCHOP(SDADC_InitStruct->SDADC_BUFFDS));
	assert_param(IS_FUNCTIONAL_STATE(SDADC_InitStruct->SDADC_Buf1));
	assert_param(IS_FUNCTIONAL_STATE(SDADC_InitStruct->SDADC_Buf2));
	assert_param(IS_SDADC_DCSET(SDADC_InitStruct->SDADC_DCSET));
	assert_param(IS_SDADC_VREFG(SDADC_InitStruct->SDADC_VREFG));
	assert_param(IS_SDADC_VREFS(SDADC_InitStruct->SDADC_VREFS));
	assert_param(IS_SDADC_ASPCK1(SDADC_InitStruct->SDADC_ASPCK1));
	assert_param(IS_SDADC_ADOUTS(SDADC_InitStruct->SDADC_ADOUTS));	
	assert_param(IS_SDADC_OSR(SDADC_InitStruct->SDADC_OSR));
	assert_param(IS_FUNCTIONAL_STATE(SDADC_InitStruct->SDADC_DIEN));
	assert_param(IS_FUNCTIONAL_STATE(SDADC_InitStruct->SDADC_PAEN));
	
	tmpreg=SDADC->SDADC_CR&0xE0800001;
	
	tmpreg1=SDADC_InitStruct->SDADC_BUFFDS;
	tmpreg|=(tmpreg1<<26);
	
	if(SDADC_InitStruct->SDADC_Buf1==ENABLE)
	tmpreg|=SDADC_CR_BUF1EN;
		
	if(SDADC_InitStruct->SDADC_Buf2==ENABLE)
	tmpreg|=SDADC_CR_BUF2EN;

	tmpreg1=SDADC_InitStruct->SDADC_DCSET;
	tmpreg|=(tmpreg1<<20);
	
	tmpreg1=SDADC_InitStruct->SDADC_VREFG;
	tmpreg|=(tmpreg1<<18);
	
	tmpreg1=SDADC_InitStruct->SDADC_VREFS;
	tmpreg|=(tmpreg1<<16);
	
	tmpreg1=SDADC_InitStruct->SDADC_ASPCK1;
	tmpreg1=256-24000000/16/tmpreg1;
	tmpreg|=(tmpreg1<<8);
    
	if(SDADC_InitStruct->SDADC_ADOUTS==SDADC_SINC3)
	tmpreg|=SDADC_CR_ADOUTS;
		
	tmpreg1=SDADC_InitStruct->SDADC_OSR;
	tmpreg|=(tmpreg1<<3);
		
	if(SDADC_InitStruct->SDADC_DIEN==ENABLE)
	tmpreg|=SDADC_CR_DIEN;
		
	if(SDADC_InitStruct->SDADC_PAEN==ENABLE)
	tmpreg|=SDADC_CR_PAEN;
 
	SDADC->SDADC_CR = tmpreg;
}

/*-----------------------------------------
 * 函数功能：使能SDADC
 * 入口参数：NewState: ENABLE或者DISABLE
 * 出口参数：None
 * 返回值  ：None
 * 编写日期：
 * 作者    ：
 *-----------------------------------------*/
void SDADC_Cmd(FunctionalState NewState)
{

	/* Check the parameters */
	assert_param(IS_FUNCTIONAL_STATE(NewState));
	
	if (NewState == ENABLE)
	{	
		SDADC->SDADC_CR|=SDADC_CR_SDADCEN;							
	} 
	else 
	{
		SDADC->SDADC_CR &=~SDADC_CR_SDADCEN;		
	}	
}

/*---------------------------------------------
 * 函数功能：使能P2EN
 * 入口参数：NewState: ENABLE或者DISABLE
 * 出口参数：NoneNone
 * 返回值  ：None
 * 编写日期：
 * 作者    ：
 *---------------------------------------------*/ 
void SDADC_P2ENCmd(FunctionalState NewState)
{
	/* Check the parameters */
	assert_param(IS_FUNCTIONAL_STATE(NewState));
	
	if (NewState == ENABLE)
	{	
		SDADC->SDADC_CR|=SDADC_CR_P2EN;							
	} 
	else 
	{
		SDADC->SDADC_CR &=~SDADC_CR_P2EN;		
	}	
}

/*---------------------------------------------
 * 函数功能：ADC中断使能
 * 入口参数：NewState: ENABLE或者DISABLE
 * 出口参数：None
 * 返回值  ：None
 * 编写日期：
 * 作者    ：
 *--------------------------------------------*/
void SDADC_ITCmd(FunctionalState NewState)
{
	/* Check the parameters */
	assert_param(IS_FUNCTIONAL_STATE(NewState));
	
	if (NewState != DISABLE)
	{
		SDADC->SDADC_CR |= SDADC_CR_SDADCIE;
	}
	else
	{
		SDADC->SDADC_CR &= ~SDADC_CR_SDADCIE;
	}
} 
 
/*-------------------------------------------
 * 函数功能：读ADC中断标志位
 * 入口参数：None
 * 出口参数：None
 * 返回值  ：ADC中断标志位 bitstatus
 * 编写日期：
 * 作者    ：
 *-----------------------------------------*/
ITStatus SDADC_GetITStatus(void)
{
	ITStatus bitstatus = RESET;

	if ((SDADC->SDADC_SR & SDADC_SR_SDADCIF) != RESET)
	{
		bitstatus = SET;
	}
	else
	{
		bitstatus = RESET;
	}
	
	return  bitstatus;	
}

/*------------------------------------------
 * 函数功能：清零ADC标志位
 * 入口参数：None
 * 出口参数：None
 * 返回值  ：None
 * 编写日期：
 * 作者    ：
 *-----------------------------------------*/
void SDADC_ClearITStatus(void)
{

	SDADC->SDADC_SR |= SDADC_SR_SDADCIF;

}

/*------------------------------------------
 * 函数功能：读ADC转换值
 * 入口参数：None
 * 出口参数：None
 * 返回值  ：ADC转换值
 * 编写日期：
 * 作者    ：
 *-----------------------------------------*/
uint32_t SDADC_GetConversionValue(void) 
{
	return (SDADC->SDADC_DR);
}
 
/*-----------------------------
 * 函数功能：BUFFER1使能
 * 入口参数：NewState: ENABLE或者DISABLE
 * 出口参数：None
 * 返回值  ：None
 * 编写日期：
 * 作者    ：
 *------------------------------*/
void SDADC_Buf1Cmd(FunctionalState NewState)
{
	/* Check the parameters */
	assert_param(IS_FUNCTIONAL_STATE(NewState));	
	if (NewState != DISABLE)
	{
		SDADC->SDADC_CR |= SDADC_CR_BUF1EN;
	}
	else
	{
		SDADC->SDADC_CR &= ~SDADC_CR_BUF1EN;
	}		
}

/*-----------------------------
 * 函数功能：BUFFER2使能
 * 入口参数：NewState: ENABLE或者DISABLE
 * 出口参数：None
 * 返回值  ：None
 * 编写日期：
 * 作者    ：
 *------------------------------*/
void SDADC_Buf2Cmd(FunctionalState NewState)
{
	/* Check the parameters */
	assert_param(IS_FUNCTIONAL_STATE(NewState));	
	if (NewState != DISABLE)
	{
		SDADC->SDADC_CR |= SDADC_CR_BUF2EN;
	}
	else
	{
		SDADC->SDADC_CR &= ~SDADC_CR_BUF2EN;
	}	
}

/*-------------------------------------
 * 函数功能：IBOUT开短路探测电流配置
 * 入口参数：SDADC_IBOUT: 可配置为 SDADC_IBOUT_0uA,SDADC_IBOUT_0uA5,SDADC_IBOUT_2uA,SDADC_IBOUT_4uA
 * 出口参数：None
 * 返回值  ：None
 * 编写日期：
 * 作者    ：
 *-------------------------------------*/
void SDADC_IBOUTCofig(uint32_t SDADC_IBOUT)
{
	/* Check the parameters */
	assert_param(IS_SDADC_IBOUT( SDADC_IBOUT));
	SDADC->IA_CR &= 0x3FFD7FFF;
	SDADC->IA_CR |= SDADC_IBOUT;
	
}

/*-------------------------------------
 * 函数功能：配置EMI的相关参数
 * 入口参数：EMIx,EMI_InitStruct
 *           EMIx: 可选择EMIA、EMIB
 *           EMI_InitStruct: pointer to a EMI_InitStruct structure that
 *           contains the configuration information for the specified EMI peripheral.
 * 出口参数：None
 * 返回值  ：None
 * 编写日期：
 * 作者    ：
 *-------------------------------------*/
void SDADC_EMIInit(uint8_t EMIx,EMI_InitTypeDef* EMI_InitStruct)
{
	uint32_t tmpreg=0,tmpreg1=0;
	/* Check the parameters */
	assert_param(IS_FUNCTIONAL_STATE(EMI_InitStruct->EMI_DELEN));
	assert_param(IS_EMI_VTH(EMI_InitStruct->EMI_VTH));
	
	tmpreg=SDADC->EMI_CR & 0x00090009;
	tmpreg1=EMI_InitStruct->EMI_VTH;
	
	if(EMIx==EMIA)
	{
		if(EMI_InitStruct->EMI_DELEN==ENABLE)
			SDADC->EMI_CR|=EMI_CR_EMIA_DELEN;
		else
			SDADC->EMI_CR&=~EMI_CR_EMIA_DELEN;
			
		SDADC->EMI_CR=(tmpreg|(tmpreg1<<1));
	}
	else
	{
		if(EMI_InitStruct->EMI_DELEN==ENABLE)
			SDADC->EMI_CR|=EMI_CR_EMIB_DELEN;
		else
			SDADC->EMI_CR&=~EMI_CR_EMIB_DELEN;
			
		SDADC->EMI_CR=(tmpreg|(tmpreg1<<17));
	}
}

/*-------------------------------------
 * 函数功能：使能EMI的检测电路
 * 入口参数：EMIx: 可选择EMIA、EMIB
 *           NewState: ENABLE或者DISABLE
 * 出口参数：None
 * 返回值  ：None
 * 编写日期：
 * 作者    ：
 *-------------------------------------*/
void SDADC_EMICmd(uint8_t EMIx,FunctionalState NewState)
{
	/* Check the parameters */	 
	assert_param(IS_FUNCTIONAL_STATE(NewState));	
	
	if (NewState == ENABLE)
	{	
		if(EMIx==EMIA)

			SDADC->EMI_CR|=EMI_CR_EMIAEN;

		else
			SDADC->EMI_CR|=EMI_CR_EMIBEN;							
	} 
	else 
	{
		if(EMIx==EMIA)
			SDADC->EMI_CR&=~EMI_CR_EMIAEN;

		else
			SDADC->EMI_CR&=~EMI_CR_EMIBEN;		
	}
}

/*-------------------------------------
 * 函数功能：获取EMI检测结果标志位
 * 入口参数：EMIx: 可选择EMIA、EMIB
 * 出口参数：None
 * 返回值  ：EMI检测结果标志位 bitstatus
 * 编写日期：
 * 作者    ：
 *-------------------------------------*/
FlagStatus SDADC_GetEMIFlagStatus(uint8_t EMIx)
{
	FlagStatus bitstatus = RESET;
	
	if(EMIx==EMIA)
	{
		if((SDADC->EMI_CR & EMI_CR_EMIAOUT)==RESET)		
			bitstatus =	RESET;		
		else 
			bitstatus = SET;
	}
	if(EMIx==EMIB)
	{
		if((SDADC->EMI_CR & EMI_CR_EMIBOUT)==RESET)		
			bitstatus =	RESET;		
		else 
			bitstatus = SET;		
	}
	return bitstatus;
}

/*-------------------------------------
 * 函数功能：清除EMI检测结果标志位
 * 入口参数：EMIx: 可选择EMIA、EMIB
 * 出口参数：None
 * 返回值  ：None
 * 编写日期：
 * 作者    ：
 *-------------------------------------*/
void SDADC_ClearEMIFlagStatus(uint8_t EMIx)
{
	if(EMIx==EMIA)
	{
		SDADC->EMI_CR|= EMI_CR_EMIAOUT;				
	}
	if(EMIx==EMIB)
	{
        SDADC->EMI_CR|= EMI_CR_EMIBOUT;			
	}
}

/*------------------------------------------------------------------------
 * 函数功能：初始化温度传感器的相关配置
 * 入口参数  TempSensor_InitStruct: pointer to a TempSensor_InitStruct structure that
 *           contains the configuration information for the specified TempSensor peripheral.
 * 出口参数：None
 * 返回值  ：None
 * 编写日期：
 * 作者    ：
 *------------------------------------------------------------------------*/ 
void SDADC_TempSensorInit(TempSensor_InitTypeDef* TempSensor_InitStruct)
{
	/* Check the parameters*/ 
	assert_param(IS_FUNCTIONAL_STATE(TempSensor_InitStruct->TempSensor_TVBS));
	assert_param(IS_FUNCTIONAL_STATE(TempSensor_InitStruct->TempSensor_TCPEN));
	assert_param(IS_FUNCTIONAL_STATE(TempSensor_InitStruct->TempSensor_TSEL));
	assert_param(IS_FUNCTIONAL_STATE(TempSensor_InitStruct->TempSensor_TSOEN));

    if(TempSensor_InitStruct->TempSensor_TVBS==ENABLE)
	{
		SDADC->TS_CR |=TS_CR_TVBS;
	}
	else
	{
		SDADC->TS_CR &=~TS_CR_TVBS;	
	}
	
	if(TempSensor_InitStruct->TempSensor_TCPEN==ENABLE)
	{
		SDADC->TS_CR |=TS_CR_TCPEN;
	}
	else
	{
		SDADC->TS_CR &=~TS_CR_TCPEN;	
	}
	
	
	if(TempSensor_InitStruct->TempSensor_TSEL==ENABLE)
	{
		SDADC->TS_CR |=TS_CR_TSEL;
	}
	else
	{
		SDADC->TS_CR &=~TS_CR_TSEL;	
	}
	
	
	if(TempSensor_InitStruct->TempSensor_TSOEN==ENABLE)
	{
		SDADC->TS_CR |=TS_CR_TSOEN;
	}
	else
	{
		SDADC->TS_CR &=~TS_CR_TSOEN;	
	}

}

/*------------------------------------------------------------
 * 函数功能：实现温度信号的正反测，
 * 入口参数：ENABLE：正测；DISABLE：反测
 * 出口参数：None
 * 返回值  ：None
 * 编写日期：
 * 作者    ：
 *------------------------------------------------------------*/ 
void SDADC_SoftTempMeasurerCmd(FunctionalState NewState)				   
{	
	/* Check the parameters*/ 
	assert_param(IS_FUNCTIONAL_STATE(NewState));	
	
	if (NewState != DISABLE)
	{
		SDADC->TS_CR &=~TS_CR_TCK;
	}
	else
	{
		SDADC->TS_CR |= TS_CR_TCK;	
	}	
}

/*--------------------------------------------------------
 * 函数功能：使能硬件测温功能
 * 入口参数：NewState: ENABLE或者DISABLE
 * 出口参数：None
 * 返回值  ：None
 * 编写日期：
 * 作者    ：
 *-------------------------------------------------------*/
void SDADC_HardTempMeasureCmd(FunctionalState NewState)
{
	/* Check the parameters */
	assert_param(IS_FUNCTIONAL_STATE(NewState));	
	if (NewState != DISABLE)
	{
		SDADC->SDADC_CR |=SDADC_CR_TEN;
	}
	else
	{
		SDADC->SDADC_CR &=~SDADC_CR_TEN;
	}
//    return (SDADC->SDADC_DR);	//?????		
}
/****************************END OF FILE****************************/


